﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace T11_Funa
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("求两数的和:{0}",MyMath.Sum(1,2));
            Console.WriteLine("求多个数之和:{0}",MyMath.Sum(1,2,3));
            Console.WriteLine("求多个数之和:{0}", MyMath.Sum(1.5,1.6));

            int[] number = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,22,18 };
            int? maxIndex = null;//ref必须有初始值
            int? max = MyMath.Max(number, ref maxIndex);
            Console.WriteLine("最大值为：{0},索引为：{1}",max,maxIndex);
            int? max2 = MyMath.Max(new int[0], ref maxIndex);
            Console.WriteLine("最大值为：{0},索引为：{1}", max2, maxIndex);

            int? minIndex = null;//out可以没有有初始值
            int? min = MyMath.Min(number, out minIndex);
            Console.WriteLine("最小值为：{0},索引为：{1}", min, minIndex);
            int? min2 = MyMath.Min(new int[0], out minIndex);
            Console.WriteLine("最小值为：{0},索引为：{1}", min2, minIndex);
            Console.ReadKey();
        }
    }
    /// <summary>
    /// 自定义数学函数库
    /// </summary>
    class MyMath
    {
        /// <summary>
        /// 求两个数的和
        /// 求多个数的和 求 更多不同类型犯人数据之和---泛型
        /// </summary>
        public static int Sum(int a, int b)
        {
            //int result=0;
            //result=a+b;
            //return  result;
            return a + b;
        }
        /*public static int Sum(params int[] values)
        {
            int result = 0;
            //局部变量可用var定义变量，类型推断
            foreach (var value in values)
            {
                result += value;
            }
            return result;
        }*/
        public static int? Sum(params int[] values)
         {
             int? result = null;
             if(values.Length>0)
             {
                 result = 0;
             //局部变量可用var定义变量，类型推断

             }
             foreach (var value in values)
             {
                 result += value;
             }
             return result;
         }
        public static double? Sum(params double[] values)
        {
            double? result = null;
            if (values.Length > 0)
            {
                result = 0;
                //局部变量可用var定义变量，类型推断

            }
            foreach (var value in values)
            {
                result += value;
            }
            return result;
        }
        /// <summary>
        /// 求最小数
        /// </summary>
        /// <param name="values"></param>
        /// <param name="minIndex"></param>
        /// <returns></returns>
        public  static int? Min(int[] values,out int? minIndex)
        {
            if(values.Length<=0)
            {
                minIndex = null;
                return null;
            }
            else
            {
                var min = values[0];
                minIndex = 0;
                for (int i = 0; i < values.Length; i++)
                {
                    if(values [i]<min)
                    {
                        min = values[i];
                        minIndex = i;
                    }
                }
                return min;
            }
        }
        /// <summary>
        /// 求最大值
        /// </summary>
        /// <param name="values"></param>
        /// <param name="maxIndex"></param>
        /// <returns></returns>
        public static int? Max(int[] values, ref int? maxIndex)
        {
            if (values.Length <= 0)
            {
                maxIndex = null;
                return null;
            }
            else
            {
                var max = values[0];
                maxIndex = 0;
                for (int i = 0; i < values.Length; i++)
                {
                    if (values[i] > max)
                    {
                        max = values[i];
                        maxIndex = i;
                    }
                }
                return max;
            }
        }
    }
}
